#include "Recast.h"
#ifdef __cplusplus
extern "C" {
#endif
void nav_rcCompactCell_Delete(rcCompactCell * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_rcCompactCell_DeleteArray(rcCompactCell * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

unsigned int nav_rcCompactCell_GetBitFieldOfCount(rcCompactCell * c_this){
	return (unsigned int)(c_this->count);
}

unsigned int nav_rcCompactCell_GetBitFieldOfIndex(rcCompactCell * c_this){
	return (unsigned int)(c_this->index);
}

rcCompactCell * nav_rcCompactCell_IndexArray(rcCompactCell * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

rcCompactCell * nav_NewrcCompactCell(){
	rcCompactCell* wrap_out = new rcCompactCell();
	return wrap_out;
}

void nav_rcCompactCell_SetFieldOfCount(rcCompactCell * c_this,unsigned int value){
	c_this->count=value;
}

void nav_rcCompactCell_SetFieldOfIndex(rcCompactCell * c_this,unsigned int value){
	c_this->index=value;
}

void nav_rcCompactHeightfield_Delete(rcCompactHeightfield * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_rcCompactHeightfield_DeleteArray(rcCompactHeightfield * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

unsigned char * * nav_rcCompactHeightfield_GetPtrToAreas(rcCompactHeightfield * c_this){
	return (unsigned char * *)(&(c_this->areas));
}

float(*nav_rcCompactHeightfield_GetPtrToBmax(rcCompactHeightfield * c_this))[3]{
	return (float(*)[3])(&(c_this->bmax));
}

float(*nav_rcCompactHeightfield_GetPtrToBmin(rcCompactHeightfield * c_this))[3]{
	return (float(*)[3])(&(c_this->bmin));
}

int * nav_rcCompactHeightfield_GetPtrToBorderSize(rcCompactHeightfield * c_this){
	return (int *)(&(c_this->borderSize));
}

rcCompactCell * * nav_rcCompactHeightfield_GetPtrToCells(rcCompactHeightfield * c_this){
	return (rcCompactCell * *)(&(c_this->cells));
}

float * nav_rcCompactHeightfield_GetPtrToCh(rcCompactHeightfield * c_this){
	return (float *)(&(c_this->ch));
}

float * nav_rcCompactHeightfield_GetPtrToCs(rcCompactHeightfield * c_this){
	return (float *)(&(c_this->cs));
}

unsigned short * * nav_rcCompactHeightfield_GetPtrToDist(rcCompactHeightfield * c_this){
	return (unsigned short * *)(&(c_this->dist));
}

int * nav_rcCompactHeightfield_GetPtrToHeight(rcCompactHeightfield * c_this){
	return (int *)(&(c_this->height));
}

unsigned short * nav_rcCompactHeightfield_GetPtrToMaxDistance(rcCompactHeightfield * c_this){
	return (unsigned short *)(&(c_this->maxDistance));
}

unsigned short * nav_rcCompactHeightfield_GetPtrToMaxRegions(rcCompactHeightfield * c_this){
	return (unsigned short *)(&(c_this->maxRegions));
}

int * nav_rcCompactHeightfield_GetPtrToSpanCount(rcCompactHeightfield * c_this){
	return (int *)(&(c_this->spanCount));
}

rcCompactSpan * * nav_rcCompactHeightfield_GetPtrToSpans(rcCompactHeightfield * c_this){
	return (rcCompactSpan * *)(&(c_this->spans));
}

int * nav_rcCompactHeightfield_GetPtrToWalkableClimb(rcCompactHeightfield * c_this){
	return (int *)(&(c_this->walkableClimb));
}

int * nav_rcCompactHeightfield_GetPtrToWalkableHeight(rcCompactHeightfield * c_this){
	return (int *)(&(c_this->walkableHeight));
}

int * nav_rcCompactHeightfield_GetPtrToWidth(rcCompactHeightfield * c_this){
	return (int *)(&(c_this->width));
}

rcCompactHeightfield * nav_rcCompactHeightfield_IndexArray(rcCompactHeightfield * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

rcCompactHeightfield * nav_NewrcCompactHeightfield(){
	rcCompactHeightfield* wrap_out = new rcCompactHeightfield();
	return wrap_out;
}

void nav_rcCompactSpan_Delete(rcCompactSpan * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_rcCompactSpan_DeleteArray(rcCompactSpan * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

unsigned int nav_rcCompactSpan_GetBitFieldOfCon(rcCompactSpan * c_this){
	return (unsigned int)(c_this->con);
}

unsigned int nav_rcCompactSpan_GetBitFieldOfH(rcCompactSpan * c_this){
	return (unsigned int)(c_this->h);
}

unsigned short * nav_rcCompactSpan_GetPtrToReg(rcCompactSpan * c_this){
	return (unsigned short *)(&(c_this->reg));
}

unsigned short * nav_rcCompactSpan_GetPtrToY(rcCompactSpan * c_this){
	return (unsigned short *)(&(c_this->y));
}

rcCompactSpan * nav_rcCompactSpan_IndexArray(rcCompactSpan * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

rcCompactSpan * nav_NewrcCompactSpan(){
	rcCompactSpan* wrap_out = new rcCompactSpan();
	return wrap_out;
}

void nav_rcCompactSpan_SetFieldOfCon(rcCompactSpan * c_this,unsigned int value){
	c_this->con=value;
}

void nav_rcCompactSpan_SetFieldOfH(rcCompactSpan * c_this,unsigned int value){
	c_this->h=value;
}

void nav_rcConfig_Delete(rcConfig * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_rcConfig_DeleteArray(rcConfig * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

float(*nav_rcConfig_GetPtrToBmax(rcConfig * c_this))[3]{
	return (float(*)[3])(&(c_this->bmax));
}

float(*nav_rcConfig_GetPtrToBmin(rcConfig * c_this))[3]{
	return (float(*)[3])(&(c_this->bmin));
}

int * nav_rcConfig_GetPtrToBorderSize(rcConfig * c_this){
	return (int *)(&(c_this->borderSize));
}

float * nav_rcConfig_GetPtrToCh(rcConfig * c_this){
	return (float *)(&(c_this->ch));
}

float * nav_rcConfig_GetPtrToCs(rcConfig * c_this){
	return (float *)(&(c_this->cs));
}

float * nav_rcConfig_GetPtrToDetailSampleDist(rcConfig * c_this){
	return (float *)(&(c_this->detailSampleDist));
}

float * nav_rcConfig_GetPtrToDetailSampleMaxError(rcConfig * c_this){
	return (float *)(&(c_this->detailSampleMaxError));
}

int * nav_rcConfig_GetPtrToHeight(rcConfig * c_this){
	return (int *)(&(c_this->height));
}

int * nav_rcConfig_GetPtrToMaxEdgeLen(rcConfig * c_this){
	return (int *)(&(c_this->maxEdgeLen));
}

float * nav_rcConfig_GetPtrToMaxSimplificationError(rcConfig * c_this){
	return (float *)(&(c_this->maxSimplificationError));
}

int * nav_rcConfig_GetPtrToMaxVertsPerPoly(rcConfig * c_this){
	return (int *)(&(c_this->maxVertsPerPoly));
}

int * nav_rcConfig_GetPtrToMergeRegionArea(rcConfig * c_this){
	return (int *)(&(c_this->mergeRegionArea));
}

int * nav_rcConfig_GetPtrToMinRegionArea(rcConfig * c_this){
	return (int *)(&(c_this->minRegionArea));
}

int * nav_rcConfig_GetPtrToTileSize(rcConfig * c_this){
	return (int *)(&(c_this->tileSize));
}

int * nav_rcConfig_GetPtrToWalkableClimb(rcConfig * c_this){
	return (int *)(&(c_this->walkableClimb));
}

int * nav_rcConfig_GetPtrToWalkableHeight(rcConfig * c_this){
	return (int *)(&(c_this->walkableHeight));
}

int * nav_rcConfig_GetPtrToWalkableRadius(rcConfig * c_this){
	return (int *)(&(c_this->walkableRadius));
}

float * nav_rcConfig_GetPtrToWalkableSlopeAngle(rcConfig * c_this){
	return (float *)(&(c_this->walkableSlopeAngle));
}

int * nav_rcConfig_GetPtrToWidth(rcConfig * c_this){
	return (int *)(&(c_this->width));
}

rcConfig * nav_rcConfig_IndexArray(rcConfig * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

rcConfig * nav_NewrcConfig(){
	rcConfig* wrap_out = new rcConfig();
	return wrap_out;
}

void nav_rcContext_Delete(rcContext * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_rcContext_DeleteArray(rcContext * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

void nav_rcContext_enableLog(rcContext * c_this,bool state){
	bool c_arg_state=state;
	c_this->enableLog(c_arg_state);
}

void nav_rcContext_enableTimer(rcContext * c_this,bool state){
	bool c_arg_state=state;
	c_this->enableTimer(c_arg_state);
}

int nav_rcContext_getAccumulatedTime(rcContext const * c_this,rcTimerLabel const label){
	rcTimerLabel const c_arg_label=label;
	int c_out = c_this->getAccumulatedTime(c_arg_label);
	int wrap_out  = (c_out);
	return wrap_out;
}

rcContext * nav_rcContext_IndexArray(rcContext * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

void nav_rcContext_log(rcContext * c_this,rcLogCategory const category,char const * format){
	rcLogCategory const c_arg_category=category;
	char const * c_arg_format=(char const *)(void*)(format);
	c_this->log(c_arg_category,c_arg_format);
}

rcContext * nav_NewrcContext(bool state){
	bool c_arg_state=state;
	rcContext* wrap_out = new rcContext(c_arg_state);
	return wrap_out;
}

void nav_rcContext_resetLog(rcContext * c_this){
	c_this->resetLog();
}

void nav_rcContext_resetTimers(rcContext * c_this){
	c_this->resetTimers();
}

void nav_rcContext_startTimer(rcContext * c_this,rcTimerLabel const label){
	rcTimerLabel const c_arg_label=label;
	c_this->startTimer(c_arg_label);
}

void nav_rcContext_stopTimer(rcContext * c_this,rcTimerLabel const label){
	rcTimerLabel const c_arg_label=label;
	c_this->stopTimer(c_arg_label);
}

void nav_rcContour_Delete(rcContour * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_rcContour_DeleteArray(rcContour * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

unsigned char * nav_rcContour_GetPtrToArea(rcContour * c_this){
	return (unsigned char *)(&(c_this->area));
}

int * nav_rcContour_GetPtrToNrverts(rcContour * c_this){
	return (int *)(&(c_this->nrverts));
}

int * nav_rcContour_GetPtrToNverts(rcContour * c_this){
	return (int *)(&(c_this->nverts));
}

unsigned short * nav_rcContour_GetPtrToReg(rcContour * c_this){
	return (unsigned short *)(&(c_this->reg));
}

int * * nav_rcContour_GetPtrToRverts(rcContour * c_this){
	return (int * *)(&(c_this->rverts));
}

int * * nav_rcContour_GetPtrToVerts(rcContour * c_this){
	return (int * *)(&(c_this->verts));
}

rcContour * nav_rcContour_IndexArray(rcContour * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

rcContour * nav_NewrcContour(){
	rcContour* wrap_out = new rcContour();
	return wrap_out;
}

void nav_rcContourSet_Delete(rcContourSet * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_rcContourSet_DeleteArray(rcContourSet * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

float(*nav_rcContourSet_GetPtrToBmax(rcContourSet * c_this))[3]{
	return (float(*)[3])(&(c_this->bmax));
}

float(*nav_rcContourSet_GetPtrToBmin(rcContourSet * c_this))[3]{
	return (float(*)[3])(&(c_this->bmin));
}

int * nav_rcContourSet_GetPtrToBorderSize(rcContourSet * c_this){
	return (int *)(&(c_this->borderSize));
}

float * nav_rcContourSet_GetPtrToCh(rcContourSet * c_this){
	return (float *)(&(c_this->ch));
}

rcContour * * nav_rcContourSet_GetPtrToConts(rcContourSet * c_this){
	return (rcContour * *)(&(c_this->conts));
}

float * nav_rcContourSet_GetPtrToCs(rcContourSet * c_this){
	return (float *)(&(c_this->cs));
}

int * nav_rcContourSet_GetPtrToHeight(rcContourSet * c_this){
	return (int *)(&(c_this->height));
}

float * nav_rcContourSet_GetPtrToMaxError(rcContourSet * c_this){
	return (float *)(&(c_this->maxError));
}

int * nav_rcContourSet_GetPtrToNconts(rcContourSet * c_this){
	return (int *)(&(c_this->nconts));
}

int * nav_rcContourSet_GetPtrToWidth(rcContourSet * c_this){
	return (int *)(&(c_this->width));
}

rcContourSet * nav_rcContourSet_IndexArray(rcContourSet * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

rcContourSet * nav_NewrcContourSet(){
	rcContourSet* wrap_out = new rcContourSet();
	return wrap_out;
}

void nav_rcHeightfield_Delete(rcHeightfield * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_rcHeightfield_DeleteArray(rcHeightfield * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

float(*nav_rcHeightfield_GetPtrToBmax(rcHeightfield * c_this))[3]{
	return (float(*)[3])(&(c_this->bmax));
}

float(*nav_rcHeightfield_GetPtrToBmin(rcHeightfield * c_this))[3]{
	return (float(*)[3])(&(c_this->bmin));
}

float * nav_rcHeightfield_GetPtrToCh(rcHeightfield * c_this){
	return (float *)(&(c_this->ch));
}

float * nav_rcHeightfield_GetPtrToCs(rcHeightfield * c_this){
	return (float *)(&(c_this->cs));
}

rcSpan * * nav_rcHeightfield_GetPtrToFreelist(rcHeightfield * c_this){
	return (rcSpan * *)(&(c_this->freelist));
}

int * nav_rcHeightfield_GetPtrToHeight(rcHeightfield * c_this){
	return (int *)(&(c_this->height));
}

rcSpanPool * * nav_rcHeightfield_GetPtrToPools(rcHeightfield * c_this){
	return (rcSpanPool * *)(&(c_this->pools));
}

rcSpan * * * nav_rcHeightfield_GetPtrToSpans(rcHeightfield * c_this){
	return (rcSpan * * *)(&(c_this->spans));
}

int * nav_rcHeightfield_GetPtrToWidth(rcHeightfield * c_this){
	return (int *)(&(c_this->width));
}

rcHeightfield * nav_rcHeightfield_IndexArray(rcHeightfield * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

rcHeightfield * nav_NewrcHeightfield(){
	rcHeightfield* wrap_out = new rcHeightfield();
	return wrap_out;
}

void nav_rcHeightfieldLayer_Delete(rcHeightfieldLayer * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_rcHeightfieldLayer_DeleteArray(rcHeightfieldLayer * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

unsigned char * * nav_rcHeightfieldLayer_GetPtrToAreas(rcHeightfieldLayer * c_this){
	return (unsigned char * *)(&(c_this->areas));
}

float(*nav_rcHeightfieldLayer_GetPtrToBmax(rcHeightfieldLayer * c_this))[3]{
	return (float(*)[3])(&(c_this->bmax));
}

float(*nav_rcHeightfieldLayer_GetPtrToBmin(rcHeightfieldLayer * c_this))[3]{
	return (float(*)[3])(&(c_this->bmin));
}

float * nav_rcHeightfieldLayer_GetPtrToCh(rcHeightfieldLayer * c_this){
	return (float *)(&(c_this->ch));
}

unsigned char * * nav_rcHeightfieldLayer_GetPtrToCons(rcHeightfieldLayer * c_this){
	return (unsigned char * *)(&(c_this->cons));
}

float * nav_rcHeightfieldLayer_GetPtrToCs(rcHeightfieldLayer * c_this){
	return (float *)(&(c_this->cs));
}

int * nav_rcHeightfieldLayer_GetPtrToHeight(rcHeightfieldLayer * c_this){
	return (int *)(&(c_this->height));
}

unsigned char * * nav_rcHeightfieldLayer_GetPtrToHeights(rcHeightfieldLayer * c_this){
	return (unsigned char * *)(&(c_this->heights));
}

int * nav_rcHeightfieldLayer_GetPtrToHmax(rcHeightfieldLayer * c_this){
	return (int *)(&(c_this->hmax));
}

int * nav_rcHeightfieldLayer_GetPtrToHmin(rcHeightfieldLayer * c_this){
	return (int *)(&(c_this->hmin));
}

int * nav_rcHeightfieldLayer_GetPtrToMaxx(rcHeightfieldLayer * c_this){
	return (int *)(&(c_this->maxx));
}

int * nav_rcHeightfieldLayer_GetPtrToMaxy(rcHeightfieldLayer * c_this){
	return (int *)(&(c_this->maxy));
}

int * nav_rcHeightfieldLayer_GetPtrToMinx(rcHeightfieldLayer * c_this){
	return (int *)(&(c_this->minx));
}

int * nav_rcHeightfieldLayer_GetPtrToMiny(rcHeightfieldLayer * c_this){
	return (int *)(&(c_this->miny));
}

int * nav_rcHeightfieldLayer_GetPtrToWidth(rcHeightfieldLayer * c_this){
	return (int *)(&(c_this->width));
}

rcHeightfieldLayer * nav_rcHeightfieldLayer_IndexArray(rcHeightfieldLayer * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

rcHeightfieldLayer * nav_NewrcHeightfieldLayer(){
	rcHeightfieldLayer* wrap_out = new rcHeightfieldLayer();
	return wrap_out;
}

void nav_rcHeightfieldLayerSet_Delete(rcHeightfieldLayerSet * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_rcHeightfieldLayerSet_DeleteArray(rcHeightfieldLayerSet * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

rcHeightfieldLayer * * nav_rcHeightfieldLayerSet_GetPtrToLayers(rcHeightfieldLayerSet * c_this){
	return (rcHeightfieldLayer * *)(&(c_this->layers));
}

int * nav_rcHeightfieldLayerSet_GetPtrToNlayers(rcHeightfieldLayerSet * c_this){
	return (int *)(&(c_this->nlayers));
}

rcHeightfieldLayerSet * nav_rcHeightfieldLayerSet_IndexArray(rcHeightfieldLayerSet * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

rcHeightfieldLayerSet * nav_NewrcHeightfieldLayerSet(){
	rcHeightfieldLayerSet* wrap_out = new rcHeightfieldLayerSet();
	return wrap_out;
}

void nav_rcPolyMesh_Delete(rcPolyMesh * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_rcPolyMesh_DeleteArray(rcPolyMesh * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

unsigned char * * nav_rcPolyMesh_GetPtrToAreas(rcPolyMesh * c_this){
	return (unsigned char * *)(&(c_this->areas));
}

float(*nav_rcPolyMesh_GetPtrToBmax(rcPolyMesh * c_this))[3]{
	return (float(*)[3])(&(c_this->bmax));
}

float(*nav_rcPolyMesh_GetPtrToBmin(rcPolyMesh * c_this))[3]{
	return (float(*)[3])(&(c_this->bmin));
}

int * nav_rcPolyMesh_GetPtrToBorderSize(rcPolyMesh * c_this){
	return (int *)(&(c_this->borderSize));
}

float * nav_rcPolyMesh_GetPtrToCh(rcPolyMesh * c_this){
	return (float *)(&(c_this->ch));
}

float * nav_rcPolyMesh_GetPtrToCs(rcPolyMesh * c_this){
	return (float *)(&(c_this->cs));
}

unsigned short * * nav_rcPolyMesh_GetPtrToFlags(rcPolyMesh * c_this){
	return (unsigned short * *)(&(c_this->flags));
}

float * nav_rcPolyMesh_GetPtrToMaxEdgeError(rcPolyMesh * c_this){
	return (float *)(&(c_this->maxEdgeError));
}

int * nav_rcPolyMesh_GetPtrToMaxpolys(rcPolyMesh * c_this){
	return (int *)(&(c_this->maxpolys));
}

int * nav_rcPolyMesh_GetPtrToNpolys(rcPolyMesh * c_this){
	return (int *)(&(c_this->npolys));
}

int * nav_rcPolyMesh_GetPtrToNverts(rcPolyMesh * c_this){
	return (int *)(&(c_this->nverts));
}

int * nav_rcPolyMesh_GetPtrToNvp(rcPolyMesh * c_this){
	return (int *)(&(c_this->nvp));
}

unsigned short * * nav_rcPolyMesh_GetPtrToPolys(rcPolyMesh * c_this){
	return (unsigned short * *)(&(c_this->polys));
}

unsigned short * * nav_rcPolyMesh_GetPtrToRegs(rcPolyMesh * c_this){
	return (unsigned short * *)(&(c_this->regs));
}

unsigned short * * nav_rcPolyMesh_GetPtrToVerts(rcPolyMesh * c_this){
	return (unsigned short * *)(&(c_this->verts));
}

rcPolyMesh * nav_rcPolyMesh_IndexArray(rcPolyMesh * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

rcPolyMesh * nav_NewrcPolyMesh(){
	rcPolyMesh* wrap_out = new rcPolyMesh();
	return wrap_out;
}

void nav_rcPolyMeshDetail_Delete(rcPolyMeshDetail * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_rcPolyMeshDetail_DeleteArray(rcPolyMeshDetail * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

unsigned int * * nav_rcPolyMeshDetail_GetPtrToMeshes(rcPolyMeshDetail * c_this){
	return (unsigned int * *)(&(c_this->meshes));
}

int * nav_rcPolyMeshDetail_GetPtrToNmeshes(rcPolyMeshDetail * c_this){
	return (int *)(&(c_this->nmeshes));
}

int * nav_rcPolyMeshDetail_GetPtrToNtris(rcPolyMeshDetail * c_this){
	return (int *)(&(c_this->ntris));
}

int * nav_rcPolyMeshDetail_GetPtrToNverts(rcPolyMeshDetail * c_this){
	return (int *)(&(c_this->nverts));
}

unsigned char * * nav_rcPolyMeshDetail_GetPtrToTris(rcPolyMeshDetail * c_this){
	return (unsigned char * *)(&(c_this->tris));
}

float * * nav_rcPolyMeshDetail_GetPtrToVerts(rcPolyMeshDetail * c_this){
	return (float * *)(&(c_this->verts));
}

rcPolyMeshDetail * nav_rcPolyMeshDetail_IndexArray(rcPolyMeshDetail * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

rcPolyMeshDetail * nav_NewrcPolyMeshDetail(){
	rcPolyMeshDetail* wrap_out = new rcPolyMeshDetail();
	return wrap_out;
}

void nav_rcScopedTimer_Delete(rcScopedTimer * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_rcScopedTimer_DeleteArray(rcScopedTimer * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

rcScopedTimer * nav_rcScopedTimer_IndexArray(rcScopedTimer * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

rcScopedTimer * nav_NewrcScopedTimer(rcContext * ctx,rcTimerLabel const label){
	rcContext * c_arg_ctx=(rcContext *)(void*)(ctx);
	rcTimerLabel const c_arg_label=label;
	rcScopedTimer* wrap_out = new rcScopedTimer(c_arg_ctx,c_arg_label);
	return wrap_out;
}

void nav_rcSpan_Delete(rcSpan * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_rcSpan_DeleteArray(rcSpan * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

unsigned int nav_rcSpan_GetBitFieldOfArea(rcSpan * c_this){
	return (unsigned int)(c_this->area);
}

unsigned int nav_rcSpan_GetBitFieldOfSmax(rcSpan * c_this){
	return (unsigned int)(c_this->smax);
}

unsigned int nav_rcSpan_GetBitFieldOfSmin(rcSpan * c_this){
	return (unsigned int)(c_this->smin);
}

rcSpan * * nav_rcSpan_GetPtrToNext(rcSpan * c_this){
	return (rcSpan * *)(&(c_this->next));
}

rcSpan * nav_rcSpan_IndexArray(rcSpan * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

rcSpan * nav_NewrcSpan(){
	rcSpan* wrap_out = new rcSpan();
	return wrap_out;
}

void nav_rcSpan_SetFieldOfArea(rcSpan * c_this,unsigned int value){
	c_this->area=value;
}

void nav_rcSpan_SetFieldOfSmax(rcSpan * c_this,unsigned int value){
	c_this->smax=value;
}

void nav_rcSpan_SetFieldOfSmin(rcSpan * c_this,unsigned int value){
	c_this->smin=value;
}

void nav_rcSpanPool_Delete(rcSpanPool * c_this){
	if(c_this==0){
	    return;
	}
	delete c_this;
}

void nav_rcSpanPool_DeleteArray(rcSpanPool * c_this){
	if(c_this==0){
		return;
	}
	delete []c_this;
}

rcSpan(*nav_rcSpanPool_GetPtrToItems(rcSpanPool * c_this))[2048]{
	return (rcSpan(*)[2048])(&(c_this->items));
}

rcSpanPool * * nav_rcSpanPool_GetPtrToNext(rcSpanPool * c_this){
	return (rcSpanPool * *)(&(c_this->next));
}

rcSpanPool * nav_rcSpanPool_IndexArray(rcSpanPool * c_this,long n){
	if(c_this==0){
		return 0;
	}
	c_this+=n;
	return c_this;
}

rcSpanPool * nav_NewrcSpanPool(){
	rcSpanPool* wrap_out = new rcSpanPool();
	return wrap_out;
}

rcCompactCell * nav_NewRcCompactCellPtrArray(long n){
	rcCompactCell* c_this=new rcCompactCell[n];
	return c_this;
}

rcCompactHeightfield * nav_NewRcCompactHeightfieldPtrArray(long n){
	rcCompactHeightfield* c_this=new rcCompactHeightfield[n];
	return c_this;
}

rcCompactSpan * nav_NewRcCompactSpanPtrArray(long n){
	rcCompactSpan* c_this=new rcCompactSpan[n];
	return c_this;
}

rcConfig * nav_NewRcConfigPtrArray(long n){
	rcConfig* c_this=new rcConfig[n];
	return c_this;
}

rcContext * nav_NewRcContextPtrArray(long n){
	rcContext* c_this=new rcContext[n];
	return c_this;
}

rcContour * nav_NewRcContourPtrArray(long n){
	rcContour* c_this=new rcContour[n];
	return c_this;
}

rcContourSet * nav_NewRcContourSetPtrArray(long n){
	rcContourSet* c_this=new rcContourSet[n];
	return c_this;
}

rcHeightfieldLayer * nav_NewRcHeightfieldLayerPtrArray(long n){
	rcHeightfieldLayer* c_this=new rcHeightfieldLayer[n];
	return c_this;
}

rcHeightfieldLayerSet * nav_NewRcHeightfieldLayerSetPtrArray(long n){
	rcHeightfieldLayerSet* c_this=new rcHeightfieldLayerSet[n];
	return c_this;
}

rcHeightfield * nav_NewRcHeightfieldPtrArray(long n){
	rcHeightfield* c_this=new rcHeightfield[n];
	return c_this;
}

rcPolyMeshDetail * nav_NewRcPolyMeshDetailPtrArray(long n){
	rcPolyMeshDetail* c_this=new rcPolyMeshDetail[n];
	return c_this;
}

rcPolyMesh * nav_NewRcPolyMeshPtrArray(long n){
	rcPolyMesh* c_this=new rcPolyMesh[n];
	return c_this;
}

rcSpanPool * nav_NewRcSpanPoolPtrArray(long n){
	rcSpanPool* c_this=new rcSpanPool[n];
	return c_this;
}

rcSpan * nav_NewRcSpanPtrArray(long n){
	rcSpan* c_this=new rcSpan[n];
	return c_this;
}

bool nav_rcAddSpan(rcContext * context,rcHeightfield * heightfield,int x,int z,unsigned short spanMin,unsigned short spanMax,unsigned char areaID,int flagMergeThreshold){
	rcContext * c_arg_context=(rcContext *)(void*)(context);
	rcHeightfield& c_arg_heightfield=*(rcHeightfield *)(heightfield);
	int c_arg_x=x;
	int c_arg_z=z;
	unsigned short c_arg_spanMin=spanMin;
	unsigned short c_arg_spanMax=spanMax;
	unsigned char c_arg_areaID=areaID;
	int c_arg_flagMergeThreshold=flagMergeThreshold;
	bool c_out = rcAddSpan(c_arg_context,c_arg_heightfield,c_arg_x,c_arg_z,c_arg_spanMin,c_arg_spanMax,c_arg_areaID,c_arg_flagMergeThreshold);
	bool wrap_out  = (c_out);
	return wrap_out;
}

rcCompactHeightfield * nav_rcAllocCompactHeightfield(){
	rcCompactHeightfield * c_out = rcAllocCompactHeightfield();
	rcCompactHeightfield * wrap_out  = (rcCompactHeightfield *)(void*)(c_out);
	return wrap_out;
}

rcContourSet * nav_rcAllocContourSet(){
	rcContourSet * c_out = rcAllocContourSet();
	rcContourSet * wrap_out  = (rcContourSet *)(void*)(c_out);
	return wrap_out;
}

rcHeightfield * nav_rcAllocHeightfield(){
	rcHeightfield * c_out = rcAllocHeightfield();
	rcHeightfield * wrap_out  = (rcHeightfield *)(void*)(c_out);
	return wrap_out;
}

rcHeightfieldLayerSet * nav_rcAllocHeightfieldLayerSet(){
	rcHeightfieldLayerSet * c_out = rcAllocHeightfieldLayerSet();
	rcHeightfieldLayerSet * wrap_out  = (rcHeightfieldLayerSet *)(void*)(c_out);
	return wrap_out;
}

rcPolyMesh * nav_rcAllocPolyMesh(){
	rcPolyMesh * c_out = rcAllocPolyMesh();
	rcPolyMesh * wrap_out  = (rcPolyMesh *)(void*)(c_out);
	return wrap_out;
}

rcPolyMeshDetail * nav_rcAllocPolyMeshDetail(){
	rcPolyMeshDetail * c_out = rcAllocPolyMeshDetail();
	rcPolyMeshDetail * wrap_out  = (rcPolyMeshDetail *)(void*)(c_out);
	return wrap_out;
}

bool nav_rcBuildCompactHeightfield(rcContext * context,int walkableHeight,int walkableClimb,rcHeightfield const * heightfield,rcCompactHeightfield * compactHeightfield){
	rcContext * c_arg_context=(rcContext *)(void*)(context);
	int c_arg_walkableHeight=walkableHeight;
	int c_arg_walkableClimb=walkableClimb;
	rcHeightfield const& c_arg_heightfield=*(rcHeightfield const *)(heightfield);
	rcCompactHeightfield& c_arg_compactHeightfield=*(rcCompactHeightfield *)(compactHeightfield);
	bool c_out = rcBuildCompactHeightfield(c_arg_context,c_arg_walkableHeight,c_arg_walkableClimb,c_arg_heightfield,c_arg_compactHeightfield);
	bool wrap_out  = (c_out);
	return wrap_out;
}

bool nav_rcBuildContours(rcContext * ctx,rcCompactHeightfield const * chf,float maxError,int maxEdgeLen,rcContourSet * cset,int buildFlags){
	rcContext * c_arg_ctx=(rcContext *)(void*)(ctx);
	rcCompactHeightfield const& c_arg_chf=*(rcCompactHeightfield const *)(chf);
	float c_arg_maxError=maxError;
	int c_arg_maxEdgeLen=maxEdgeLen;
	rcContourSet& c_arg_cset=*(rcContourSet *)(cset);
	int c_arg_buildFlags=buildFlags;
	bool c_out = rcBuildContours(c_arg_ctx,c_arg_chf,c_arg_maxError,c_arg_maxEdgeLen,c_arg_cset,c_arg_buildFlags);
	bool wrap_out  = (c_out);
	return wrap_out;
}

bool nav_rcBuildDistanceField(rcContext * ctx,rcCompactHeightfield * chf){
	rcContext * c_arg_ctx=(rcContext *)(void*)(ctx);
	rcCompactHeightfield& c_arg_chf=*(rcCompactHeightfield *)(chf);
	bool c_out = rcBuildDistanceField(c_arg_ctx,c_arg_chf);
	bool wrap_out  = (c_out);
	return wrap_out;
}

bool nav_rcBuildHeightfieldLayers(rcContext * ctx,rcCompactHeightfield const * chf,int borderSize,int walkableHeight,rcHeightfieldLayerSet * lset){
	rcContext * c_arg_ctx=(rcContext *)(void*)(ctx);
	rcCompactHeightfield const& c_arg_chf=*(rcCompactHeightfield const *)(chf);
	int c_arg_borderSize=borderSize;
	int c_arg_walkableHeight=walkableHeight;
	rcHeightfieldLayerSet& c_arg_lset=*(rcHeightfieldLayerSet *)(lset);
	bool c_out = rcBuildHeightfieldLayers(c_arg_ctx,c_arg_chf,c_arg_borderSize,c_arg_walkableHeight,c_arg_lset);
	bool wrap_out  = (c_out);
	return wrap_out;
}

bool nav_rcBuildLayerRegions(rcContext * ctx,rcCompactHeightfield * chf,int borderSize,int minRegionArea){
	rcContext * c_arg_ctx=(rcContext *)(void*)(ctx);
	rcCompactHeightfield& c_arg_chf=*(rcCompactHeightfield *)(chf);
	int c_arg_borderSize=borderSize;
	int c_arg_minRegionArea=minRegionArea;
	bool c_out = rcBuildLayerRegions(c_arg_ctx,c_arg_chf,c_arg_borderSize,c_arg_minRegionArea);
	bool wrap_out  = (c_out);
	return wrap_out;
}

bool nav_rcBuildPolyMesh(rcContext * ctx,rcContourSet const * cset,int const nvp,rcPolyMesh * mesh){
	rcContext * c_arg_ctx=(rcContext *)(void*)(ctx);
	rcContourSet const& c_arg_cset=*(rcContourSet const *)(cset);
	int const c_arg_nvp=nvp;
	rcPolyMesh& c_arg_mesh=*(rcPolyMesh *)(mesh);
	bool c_out = rcBuildPolyMesh(c_arg_ctx,c_arg_cset,c_arg_nvp,c_arg_mesh);
	bool wrap_out  = (c_out);
	return wrap_out;
}

bool nav_rcBuildPolyMeshDetail(rcContext * ctx,rcPolyMesh const * mesh,rcCompactHeightfield const * chf,float sampleDist,float sampleMaxError,rcPolyMeshDetail * dmesh){
	rcContext * c_arg_ctx=(rcContext *)(void*)(ctx);
	rcPolyMesh const& c_arg_mesh=*(rcPolyMesh const *)(mesh);
	rcCompactHeightfield const& c_arg_chf=*(rcCompactHeightfield const *)(chf);
	float c_arg_sampleDist=sampleDist;
	float c_arg_sampleMaxError=sampleMaxError;
	rcPolyMeshDetail& c_arg_dmesh=*(rcPolyMeshDetail *)(dmesh);
	bool c_out = rcBuildPolyMeshDetail(c_arg_ctx,c_arg_mesh,c_arg_chf,c_arg_sampleDist,c_arg_sampleMaxError,c_arg_dmesh);
	bool wrap_out  = (c_out);
	return wrap_out;
}

bool nav_rcBuildRegions(rcContext * ctx,rcCompactHeightfield * chf,int borderSize,int minRegionArea,int mergeRegionArea){
	rcContext * c_arg_ctx=(rcContext *)(void*)(ctx);
	rcCompactHeightfield& c_arg_chf=*(rcCompactHeightfield *)(chf);
	int c_arg_borderSize=borderSize;
	int c_arg_minRegionArea=minRegionArea;
	int c_arg_mergeRegionArea=mergeRegionArea;
	bool c_out = rcBuildRegions(c_arg_ctx,c_arg_chf,c_arg_borderSize,c_arg_minRegionArea,c_arg_mergeRegionArea);
	bool wrap_out  = (c_out);
	return wrap_out;
}

bool nav_rcBuildRegionsMonotone(rcContext * ctx,rcCompactHeightfield * chf,int borderSize,int minRegionArea,int mergeRegionArea){
	rcContext * c_arg_ctx=(rcContext *)(void*)(ctx);
	rcCompactHeightfield& c_arg_chf=*(rcCompactHeightfield *)(chf);
	int c_arg_borderSize=borderSize;
	int c_arg_minRegionArea=minRegionArea;
	int c_arg_mergeRegionArea=mergeRegionArea;
	bool c_out = rcBuildRegionsMonotone(c_arg_ctx,c_arg_chf,c_arg_borderSize,c_arg_minRegionArea,c_arg_mergeRegionArea);
	bool wrap_out  = (c_out);
	return wrap_out;
}

void nav_rcCalcBounds(float const * verts,int numVerts,float * minBounds,float * maxBounds){
	float const * c_arg_verts=(float const *)(void*)(verts);
	int c_arg_numVerts=numVerts;
	float * c_arg_minBounds=(float *)(void*)(minBounds);
	float * c_arg_maxBounds=(float *)(void*)(maxBounds);
	rcCalcBounds(c_arg_verts,c_arg_numVerts,c_arg_minBounds,c_arg_maxBounds);
}

void nav_rcCalcGridSize(float const * minBounds,float const * maxBounds,float cellSize,int * sizeX,int * sizeZ){
	float const * c_arg_minBounds=(float const *)(void*)(minBounds);
	float const * c_arg_maxBounds=(float const *)(void*)(maxBounds);
	float c_arg_cellSize=cellSize;
	int * c_arg_sizeX=(int *)(void*)(sizeX);
	int * c_arg_sizeZ=(int *)(void*)(sizeZ);
	rcCalcGridSize(c_arg_minBounds,c_arg_maxBounds,c_arg_cellSize,c_arg_sizeX,c_arg_sizeZ);
}

void nav_rcClearUnwalkableTriangles(rcContext * context,float walkableSlopeAngle,float const * verts,int numVerts,int const * tris,int numTris,unsigned char * triAreaIDs){
	rcContext * c_arg_context=(rcContext *)(void*)(context);
	float c_arg_walkableSlopeAngle=walkableSlopeAngle;
	float const * c_arg_verts=(float const *)(void*)(verts);
	int c_arg_numVerts=numVerts;
	int const * c_arg_tris=(int const *)(void*)(tris);
	int c_arg_numTris=numTris;
	unsigned char * c_arg_triAreaIDs=(unsigned char *)(void*)(triAreaIDs);
	rcClearUnwalkableTriangles(c_arg_context,c_arg_walkableSlopeAngle,c_arg_verts,c_arg_numVerts,c_arg_tris,c_arg_numTris,c_arg_triAreaIDs);
}

bool nav_rcCopyPolyMesh(rcContext * ctx,rcPolyMesh const * src,rcPolyMesh * dst){
	rcContext * c_arg_ctx=(rcContext *)(void*)(ctx);
	rcPolyMesh const& c_arg_src=*(rcPolyMesh const *)(src);
	rcPolyMesh& c_arg_dst=*(rcPolyMesh *)(dst);
	bool c_out = rcCopyPolyMesh(c_arg_ctx,c_arg_src,c_arg_dst);
	bool wrap_out  = (c_out);
	return wrap_out;
}

bool nav_rcCreateHeightfield(rcContext * context,rcHeightfield * heightfield,int sizeX,int sizeZ,float const * minBounds,float const * maxBounds,float cellSize,float cellHeight){
	rcContext * c_arg_context=(rcContext *)(void*)(context);
	rcHeightfield& c_arg_heightfield=*(rcHeightfield *)(heightfield);
	int c_arg_sizeX=sizeX;
	int c_arg_sizeZ=sizeZ;
	float const * c_arg_minBounds=(float const *)(void*)(minBounds);
	float const * c_arg_maxBounds=(float const *)(void*)(maxBounds);
	float c_arg_cellSize=cellSize;
	float c_arg_cellHeight=cellHeight;
	bool c_out = rcCreateHeightfield(c_arg_context,c_arg_heightfield,c_arg_sizeX,c_arg_sizeZ,c_arg_minBounds,c_arg_maxBounds,c_arg_cellSize,c_arg_cellHeight);
	bool wrap_out  = (c_out);
	return wrap_out;
}

bool nav_rcErodeWalkableArea(rcContext * context,int erosionRadius,rcCompactHeightfield * compactHeightfield){
	rcContext * c_arg_context=(rcContext *)(void*)(context);
	int c_arg_erosionRadius=erosionRadius;
	rcCompactHeightfield& c_arg_compactHeightfield=*(rcCompactHeightfield *)(compactHeightfield);
	bool c_out = rcErodeWalkableArea(c_arg_context,c_arg_erosionRadius,c_arg_compactHeightfield);
	bool wrap_out  = (c_out);
	return wrap_out;
}

void nav_rcFilterLedgeSpans(rcContext * context,int walkableHeight,int walkableClimb,rcHeightfield * heightfield){
	rcContext * c_arg_context=(rcContext *)(void*)(context);
	int c_arg_walkableHeight=walkableHeight;
	int c_arg_walkableClimb=walkableClimb;
	rcHeightfield& c_arg_heightfield=*(rcHeightfield *)(heightfield);
	rcFilterLedgeSpans(c_arg_context,c_arg_walkableHeight,c_arg_walkableClimb,c_arg_heightfield);
}

void nav_rcFilterLowHangingWalkableObstacles(rcContext * context,int walkableClimb,rcHeightfield * heightfield){
	rcContext * c_arg_context=(rcContext *)(void*)(context);
	int c_arg_walkableClimb=walkableClimb;
	rcHeightfield& c_arg_heightfield=*(rcHeightfield *)(heightfield);
	rcFilterLowHangingWalkableObstacles(c_arg_context,c_arg_walkableClimb,c_arg_heightfield);
}

void nav_rcFilterWalkableLowHeightSpans(rcContext * context,int walkableHeight,rcHeightfield * heightfield){
	rcContext * c_arg_context=(rcContext *)(void*)(context);
	int c_arg_walkableHeight=walkableHeight;
	rcHeightfield& c_arg_heightfield=*(rcHeightfield *)(heightfield);
	rcFilterWalkableLowHeightSpans(c_arg_context,c_arg_walkableHeight,c_arg_heightfield);
}

void nav_rcFreeCompactHeightfield(rcCompactHeightfield * compactHeightfield){
	rcCompactHeightfield * c_arg_compactHeightfield=(rcCompactHeightfield *)(void*)(compactHeightfield);
	rcFreeCompactHeightfield(c_arg_compactHeightfield);
}

void nav_rcFreeContourSet(rcContourSet * contourSet){
	rcContourSet * c_arg_contourSet=(rcContourSet *)(void*)(contourSet);
	rcFreeContourSet(c_arg_contourSet);
}

void nav_rcFreeHeightField(rcHeightfield * heightfield){
	rcHeightfield * c_arg_heightfield=(rcHeightfield *)(void*)(heightfield);
	rcFreeHeightField(c_arg_heightfield);
}

void nav_rcFreeHeightfieldLayerSet(rcHeightfieldLayerSet * layerSet){
	rcHeightfieldLayerSet * c_arg_layerSet=(rcHeightfieldLayerSet *)(void*)(layerSet);
	rcFreeHeightfieldLayerSet(c_arg_layerSet);
}

void nav_rcFreePolyMesh(rcPolyMesh * polyMesh){
	rcPolyMesh * c_arg_polyMesh=(rcPolyMesh *)(void*)(polyMesh);
	rcFreePolyMesh(c_arg_polyMesh);
}

void nav_rcFreePolyMeshDetail(rcPolyMeshDetail * detailMesh){
	rcPolyMeshDetail * c_arg_detailMesh=(rcPolyMeshDetail *)(void*)(detailMesh);
	rcFreePolyMeshDetail(c_arg_detailMesh);
}

int nav_rcGetCon(rcCompactSpan const * span,int direction){
	rcCompactSpan const& c_arg_span=*(rcCompactSpan const *)(span);
	int c_arg_direction=direction;
	int c_out = rcGetCon(c_arg_span,c_arg_direction);
	int wrap_out  = (c_out);
	return wrap_out;
}

int nav_rcGetDirForOffset(int offsetX,int offsetZ){
	int c_arg_offsetX=offsetX;
	int c_arg_offsetZ=offsetZ;
	int c_out = rcGetDirForOffset(c_arg_offsetX,c_arg_offsetZ);
	int wrap_out  = (c_out);
	return wrap_out;
}

int nav_rcGetDirOffsetX(int direction){
	int c_arg_direction=direction;
	int c_out = rcGetDirOffsetX(c_arg_direction);
	int wrap_out  = (c_out);
	return wrap_out;
}

int nav_rcGetDirOffsetY(int direction){
	int c_arg_direction=direction;
	int c_out = rcGetDirOffsetY(c_arg_direction);
	int wrap_out  = (c_out);
	return wrap_out;
}

int nav_rcGetHeightFieldSpanCount(rcContext * context,rcHeightfield const * heightfield){
	rcContext * c_arg_context=(rcContext *)(void*)(context);
	rcHeightfield const& c_arg_heightfield=*(rcHeightfield const *)(heightfield);
	int c_out = rcGetHeightFieldSpanCount(c_arg_context,c_arg_heightfield);
	int wrap_out  = (c_out);
	return wrap_out;
}

void nav_rcMarkBoxArea(rcContext * context,float const * boxMinBounds,float const * boxMaxBounds,unsigned char areaId,rcCompactHeightfield * compactHeightfield){
	rcContext * c_arg_context=(rcContext *)(void*)(context);
	float const * c_arg_boxMinBounds=(float const *)(void*)(boxMinBounds);
	float const * c_arg_boxMaxBounds=(float const *)(void*)(boxMaxBounds);
	unsigned char c_arg_areaId=areaId;
	rcCompactHeightfield& c_arg_compactHeightfield=*(rcCompactHeightfield *)(compactHeightfield);
	rcMarkBoxArea(c_arg_context,c_arg_boxMinBounds,c_arg_boxMaxBounds,c_arg_areaId,c_arg_compactHeightfield);
}

void nav_rcMarkConvexPolyArea(rcContext * context,float const * verts,int numVerts,float minY,float maxY,unsigned char areaId,rcCompactHeightfield * compactHeightfield){
	rcContext * c_arg_context=(rcContext *)(void*)(context);
	float const * c_arg_verts=(float const *)(void*)(verts);
	int c_arg_numVerts=numVerts;
	float c_arg_minY=minY;
	float c_arg_maxY=maxY;
	unsigned char c_arg_areaId=areaId;
	rcCompactHeightfield& c_arg_compactHeightfield=*(rcCompactHeightfield *)(compactHeightfield);
	rcMarkConvexPolyArea(c_arg_context,c_arg_verts,c_arg_numVerts,c_arg_minY,c_arg_maxY,c_arg_areaId,c_arg_compactHeightfield);
}

void nav_rcMarkCylinderArea(rcContext * context,float const * position,float radius,float height,unsigned char areaId,rcCompactHeightfield * compactHeightfield){
	rcContext * c_arg_context=(rcContext *)(void*)(context);
	float const * c_arg_position=(float const *)(void*)(position);
	float c_arg_radius=radius;
	float c_arg_height=height;
	unsigned char c_arg_areaId=areaId;
	rcCompactHeightfield& c_arg_compactHeightfield=*(rcCompactHeightfield *)(compactHeightfield);
	rcMarkCylinderArea(c_arg_context,c_arg_position,c_arg_radius,c_arg_height,c_arg_areaId,c_arg_compactHeightfield);
}

void nav_rcMarkWalkableTriangles(rcContext * context,float walkableSlopeAngle,float const * verts,int numVerts,int const * tris,int numTris,unsigned char * triAreaIDs){
	rcContext * c_arg_context=(rcContext *)(void*)(context);
	float c_arg_walkableSlopeAngle=walkableSlopeAngle;
	float const * c_arg_verts=(float const *)(void*)(verts);
	int c_arg_numVerts=numVerts;
	int const * c_arg_tris=(int const *)(void*)(tris);
	int c_arg_numTris=numTris;
	unsigned char * c_arg_triAreaIDs=(unsigned char *)(void*)(triAreaIDs);
	rcMarkWalkableTriangles(c_arg_context,c_arg_walkableSlopeAngle,c_arg_verts,c_arg_numVerts,c_arg_tris,c_arg_numTris,c_arg_triAreaIDs);
}

bool nav_rcMedianFilterWalkableArea(rcContext * context,rcCompactHeightfield * compactHeightfield){
	rcContext * c_arg_context=(rcContext *)(void*)(context);
	rcCompactHeightfield& c_arg_compactHeightfield=*(rcCompactHeightfield *)(compactHeightfield);
	bool c_out = rcMedianFilterWalkableArea(c_arg_context,c_arg_compactHeightfield);
	bool wrap_out  = (c_out);
	return wrap_out;
}

bool nav_rcMergePolyMeshDetails(rcContext * ctx,rcPolyMeshDetail * * meshes,int const nmeshes,rcPolyMeshDetail * mesh){
	rcContext * c_arg_ctx=(rcContext *)(void*)(ctx);
	rcPolyMeshDetail * * c_arg_meshes=(rcPolyMeshDetail * *)(void*)(meshes);
	int const c_arg_nmeshes=nmeshes;
	rcPolyMeshDetail& c_arg_mesh=*(rcPolyMeshDetail *)(mesh);
	bool c_out = rcMergePolyMeshDetails(c_arg_ctx,c_arg_meshes,c_arg_nmeshes,c_arg_mesh);
	bool wrap_out  = (c_out);
	return wrap_out;
}

bool nav_rcMergePolyMeshes(rcContext * ctx,rcPolyMesh * * meshes,int const nmeshes,rcPolyMesh * mesh){
	rcContext * c_arg_ctx=(rcContext *)(void*)(ctx);
	rcPolyMesh * * c_arg_meshes=(rcPolyMesh * *)(void*)(meshes);
	int const c_arg_nmeshes=nmeshes;
	rcPolyMesh& c_arg_mesh=*(rcPolyMesh *)(mesh);
	bool c_out = rcMergePolyMeshes(c_arg_ctx,c_arg_meshes,c_arg_nmeshes,c_arg_mesh);
	bool wrap_out  = (c_out);
	return wrap_out;
}

int nav_rcOffsetPoly(float const * verts,int numVerts,float offset,float * outVerts,int maxOutVerts){
	float const * c_arg_verts=(float const *)(void*)(verts);
	int c_arg_numVerts=numVerts;
	float c_arg_offset=offset;
	float * c_arg_outVerts=(float *)(void*)(outVerts);
	int c_arg_maxOutVerts=maxOutVerts;
	int c_out = rcOffsetPoly(c_arg_verts,c_arg_numVerts,c_arg_offset,c_arg_outVerts,c_arg_maxOutVerts);
	int wrap_out  = (c_out);
	return wrap_out;
}

bool nav_rcRasterizeTriangle(rcContext * context,float const * v0,float const * v1,float const * v2,unsigned char areaID,rcHeightfield * heightfield,int flagMergeThreshold){
	rcContext * c_arg_context=(rcContext *)(void*)(context);
	float const * c_arg_v0=(float const *)(void*)(v0);
	float const * c_arg_v1=(float const *)(void*)(v1);
	float const * c_arg_v2=(float const *)(void*)(v2);
	unsigned char c_arg_areaID=areaID;
	rcHeightfield& c_arg_heightfield=*(rcHeightfield *)(heightfield);
	int c_arg_flagMergeThreshold=flagMergeThreshold;
	bool c_out = rcRasterizeTriangle(c_arg_context,c_arg_v0,c_arg_v1,c_arg_v2,c_arg_areaID,c_arg_heightfield,c_arg_flagMergeThreshold);
	bool wrap_out  = (c_out);
	return wrap_out;
}

bool nav_rcRasterizeTriangles(rcContext * context,float const * verts,int numVerts,int const * tris,unsigned char const * triAreaIDs,int numTris,rcHeightfield * heightfield,int flagMergeThreshold){
	rcContext * c_arg_context=(rcContext *)(void*)(context);
	float const * c_arg_verts=(float const *)(void*)(verts);
	int c_arg_numVerts=numVerts;
	int const * c_arg_tris=(int const *)(void*)(tris);
	unsigned char const * c_arg_triAreaIDs=(unsigned char const *)(void*)(triAreaIDs);
	int c_arg_numTris=numTris;
	rcHeightfield& c_arg_heightfield=*(rcHeightfield *)(heightfield);
	int c_arg_flagMergeThreshold=flagMergeThreshold;
	bool c_out = rcRasterizeTriangles(c_arg_context,c_arg_verts,c_arg_numVerts,c_arg_tris,c_arg_triAreaIDs,c_arg_numTris,c_arg_heightfield,c_arg_flagMergeThreshold);
	bool wrap_out  = (c_out);
	return wrap_out;
}

bool nav_rcRasterizeTriangles11(rcContext * context,float const * verts,int numVerts,unsigned short const * tris,unsigned char const * triAreaIDs,int numTris,rcHeightfield * heightfield,int flagMergeThreshold){
	rcContext * c_arg_context=(rcContext *)(void*)(context);
	float const * c_arg_verts=(float const *)(void*)(verts);
	int c_arg_numVerts=numVerts;
	unsigned short const * c_arg_tris=(unsigned short const *)(void*)(tris);
	unsigned char const * c_arg_triAreaIDs=(unsigned char const *)(void*)(triAreaIDs);
	int c_arg_numTris=numTris;
	rcHeightfield& c_arg_heightfield=*(rcHeightfield *)(heightfield);
	int c_arg_flagMergeThreshold=flagMergeThreshold;
	bool c_out = rcRasterizeTriangles(c_arg_context,c_arg_verts,c_arg_numVerts,c_arg_tris,c_arg_triAreaIDs,c_arg_numTris,c_arg_heightfield,c_arg_flagMergeThreshold);
	bool wrap_out  = (c_out);
	return wrap_out;
}

bool nav_rcRasterizeTriangles12(rcContext * context,float const * verts,unsigned char const * triAreaIDs,int numTris,rcHeightfield * heightfield,int flagMergeThreshold){
	rcContext * c_arg_context=(rcContext *)(void*)(context);
	float const * c_arg_verts=(float const *)(void*)(verts);
	unsigned char const * c_arg_triAreaIDs=(unsigned char const *)(void*)(triAreaIDs);
	int c_arg_numTris=numTris;
	rcHeightfield& c_arg_heightfield=*(rcHeightfield *)(heightfield);
	int c_arg_flagMergeThreshold=flagMergeThreshold;
	bool c_out = rcRasterizeTriangles(c_arg_context,c_arg_verts,c_arg_triAreaIDs,c_arg_numTris,c_arg_heightfield,c_arg_flagMergeThreshold);
	bool wrap_out  = (c_out);
	return wrap_out;
}

void nav_rcSetCon(rcCompactSpan * span,int direction,int neighborIndex){
	rcCompactSpan& c_arg_span=*(rcCompactSpan *)(span);
	int c_arg_direction=direction;
	int c_arg_neighborIndex=neighborIndex;
	rcSetCon(c_arg_span,c_arg_direction,c_arg_neighborIndex);
}

float nav_rcSqrt(float x){
	float c_arg_x=x;
	float c_out = rcSqrt(c_arg_x);
	float wrap_out  = (c_out);
	return wrap_out;
}

void nav_rcVadd(float * dest,float const * v1,float const * v2){
	float * c_arg_dest=(float *)(void*)(dest);
	float const * c_arg_v1=(float const *)(void*)(v1);
	float const * c_arg_v2=(float const *)(void*)(v2);
	rcVadd(c_arg_dest,c_arg_v1,c_arg_v2);
}

void nav_rcVcopy(float * dest,float const * v){
	float * c_arg_dest=(float *)(void*)(dest);
	float const * c_arg_v=(float const *)(void*)(v);
	rcVcopy(c_arg_dest,c_arg_v);
}

void nav_rcVcross(float * dest,float const * v1,float const * v2){
	float * c_arg_dest=(float *)(void*)(dest);
	float const * c_arg_v1=(float const *)(void*)(v1);
	float const * c_arg_v2=(float const *)(void*)(v2);
	rcVcross(c_arg_dest,c_arg_v1,c_arg_v2);
}

float nav_rcVdist(float const * v1,float const * v2){
	float const * c_arg_v1=(float const *)(void*)(v1);
	float const * c_arg_v2=(float const *)(void*)(v2);
	float c_out = rcVdist(c_arg_v1,c_arg_v2);
	float wrap_out  = (c_out);
	return wrap_out;
}

float nav_rcVdistSqr(float const * v1,float const * v2){
	float const * c_arg_v1=(float const *)(void*)(v1);
	float const * c_arg_v2=(float const *)(void*)(v2);
	float c_out = rcVdistSqr(c_arg_v1,c_arg_v2);
	float wrap_out  = (c_out);
	return wrap_out;
}

float nav_rcVdot(float const * v1,float const * v2){
	float const * c_arg_v1=(float const *)(void*)(v1);
	float const * c_arg_v2=(float const *)(void*)(v2);
	float c_out = rcVdot(c_arg_v1,c_arg_v2);
	float wrap_out  = (c_out);
	return wrap_out;
}

void nav_rcVmad(float * dest,float const * v1,float const * v2,float const s){
	float * c_arg_dest=(float *)(void*)(dest);
	float const * c_arg_v1=(float const *)(void*)(v1);
	float const * c_arg_v2=(float const *)(void*)(v2);
	float const c_arg_s=s;
	rcVmad(c_arg_dest,c_arg_v1,c_arg_v2,c_arg_s);
}

void nav_rcVmax(float * mx,float const * v){
	float * c_arg_mx=(float *)(void*)(mx);
	float const * c_arg_v=(float const *)(void*)(v);
	rcVmax(c_arg_mx,c_arg_v);
}

void nav_rcVmin(float * mn,float const * v){
	float * c_arg_mn=(float *)(void*)(mn);
	float const * c_arg_v=(float const *)(void*)(v);
	rcVmin(c_arg_mn,c_arg_v);
}

void nav_rcVnormalize(float * v){
	float * c_arg_v=(float *)(void*)(v);
	rcVnormalize(c_arg_v);
}

void nav_rcVsub(float * dest,float const * v1,float const * v2){
	float * c_arg_dest=(float *)(void*)(dest);
	float const * c_arg_v1=(float const *)(void*)(v1);
	float const * c_arg_v2=(float const *)(void*)(v2);
	rcVsub(c_arg_dest,c_arg_v1,c_arg_v2);
}

#ifdef __cplusplus
}
#endif
